#include "button_manager.h"
#include "pin_config.h"
#include "serial_command_handler.h"
#include "led_control_center.h"

ButtonManager::ButtonManager(uint8_t pin, LEDManager* led, WiFiManager* wifi, 
                            bool* sysPower, bool* drawingActive, bool* drawingPaused) {
  buttonPin = pin;
  ledManager = led;
  ledControlCenter = nullptr;
  wifiManager = wifi;
  serialCommandHandler = nullptr;
  systemPowerEnabled = sysPower;
  isDrawingActive = drawingActive;
  isDrawingPaused = drawingPaused;
  
  // 初始化状态变量
  currentState = BUTTON_IDLE;
  buttonPressStart = 0;
  lastButtonPress = 0;
  lastSecondPrompt = 0;
  buttonPressed = false;
  
  // 初始化触发标志
  wifiResetTriggered = false;
  systemPowerTriggered = false;
  longPressLogShown = false;
  
  // 初始化WS2812临时状态
  ws2812OriginalState = true;
  ws2812TemporarilyEnabled = false;
  
  // 初始化稳定性增强变量
  consecutiveReadings = 0;
  lastReadingState = HIGH;  // 默认按钮未按下状态
  stateChangeTime = 0;
}

ButtonManager::~ButtonManager() {
  // 析构函数中确保恢复WS2812状态
  if (ws2812TemporarilyEnabled && ledControlCenter != nullptr) {
    ledControlCenter->enableWS2812(ws2812OriginalState);
  }
}

// ==================== 内部辅助方法 ====================

bool ButtonManager::validatePointers() {
  // 验证关键指针的有效性
  return (systemPowerEnabled != nullptr && 
          isDrawingActive != nullptr && 
          isDrawingPaused != nullptr);
}

unsigned long ButtonManager::safeTimeDiff(unsigned long start, unsigned long end) {
  // 处理millis()溢出的安全时间差计算
  if (end >= start) {
    return end - start;
  } else {
    // 处理溢出情况 (大约49.7天后发生)
    return (ULONG_MAX - start) + end + 1;
  }
}

bool ButtonManager::readButtonWithDebounce() {
  bool currentReading = digitalRead(buttonPin);
  unsigned long currentTime = millis();
  
  // 如果读取状态与上次不同，重置计数
  if (currentReading != lastReadingState) {
    lastReadingState = currentReading;
    consecutiveReadings = 1;
    stateChangeTime = currentTime;
    return buttonPressed; // 返回当前状态，不改变
  }
  
  // 状态相同，增加计数
  consecutiveReadings++;
  
  // 需要足够的连续读取和时间间隔来确认状态变化
  if (consecutiveReadings >= STABLE_READINGS && 
      safeTimeDiff(stateChangeTime, currentTime) >= DEBOUNCE_DELAY) {
    
    // 状态稳定，可以更新
    bool newPressed = (currentReading == LOW);
    if (newPressed != buttonPressed) {
      Serial.printf("🔘 按钮状态稳定变化: %s -> %s (连续读取%d次，时间间隔%lums)\n", 
                   buttonPressed ? "按下" : "释放", 
                   newPressed ? "按下" : "释放",
                   consecutiveReadings,
                   safeTimeDiff(stateChangeTime, currentTime));
      return newPressed;
    }
  }
  
  return buttonPressed; // 状态未稳定变化
}

void ButtonManager::begin() {
  // 初始化按钮引脚
  pinMode(buttonPin, INPUT_PULLUP);
  
  // 验证关键指针
  if (!validatePointers()) {
    Serial.println("❌ ButtonManager初始化失败: 关键指针为空");
    return;
  }
  
  Serial.printf("🔘 按钮管理器初始化完成 - 引脚: %d\n", buttonPin);
  Serial.println("🔘 按钮功能说明:");
  Serial.println("   短按 (50-500ms): 开始/停止绘图 (系统运行时)");
  Serial.println("   长按 3秒: 系统休眠/唤醒 (只影响电机和灯带，网络功能继续)");
  Serial.println("   长按 10秒: WiFi配置重置并重启");
  Serial.println("🔘 按钮状态:");
  Serial.printf("   系统状态: %s\n", isSystemEnabled() ? "运行中" : "休眠中");
  Serial.printf("   绘图状态: %s\n", (isDrawingActive && *isDrawingActive) ? "活动" : "停止");
}

void ButtonManager::update() {
  // 验证关键指针
  if (!validatePointers()) {
    return;
  }
  
  unsigned long currentTime = millis();
  
  // 按键时间溢出保护：只有在按钮被按下时才检查溢出
  if (buttonPressed && safeTimeDiff(buttonPressStart, currentTime) > MAX_PRESS_TIME) {
    // 如果WiFi重置已经触发，直接执行WiFi重置而不是重置状态
    if (wifiResetTriggered) {
      Serial.println("✅ 检测到超长按压且WiFi重置已触发 - 立即执行WiFi重置");
      onWiFiReset();
      resetButtonState();
      return;
    }
    Serial.println("⚠️ 按钮按压时间超时，执行溢出保护");
    resetButtonState();
    return;
  }
  
  // 使用防抖读取按钮状态
  bool stableButtonState = readButtonWithDebounce();
  
  // 按钮按下检测 (LOW = 按下，因为使用了内部上拉)
  if (stableButtonState && !buttonPressed) {
    handleButtonPress();
  }
  
  // 按钮释放检测
  if (!stableButtonState && buttonPressed) {
    unsigned long pressDuration = safeTimeDiff(buttonPressStart, currentTime);
    handleButtonRelease(pressDuration);
  }
  
  // 长按时间检测 (在按钮仍被按住时)
  if (buttonPressed) {
    unsigned long pressDuration = safeTimeDiff(buttonPressStart, currentTime);
    handleLongPress(pressDuration);
  }
}

void ButtonManager::handleButtonPress() {
  unsigned long currentTime = millis();
  
  buttonPressed = true;
  buttonPressStart = currentTime;
  currentState = BUTTON_PRESSED;
  
  // 重置所有触发标志
  wifiResetTriggered = false;
  systemPowerTriggered = false;
  longPressLogShown = false;
  
  Serial.println("🔘 按钮按下");
  Serial.println("💡 短按(50-500ms)：切换开始/停止绘图");
  Serial.println("⏳ 长按3秒：系统休眠/唤醒切换");
  Serial.println("⏳ 长按10秒：重置WiFi配置");
  Serial.println("⏳ 请继续按住按钮或松开...");
  
  // 按钮按下时临时启用WS2812显示
  enableTemporaryWS2812();
}

void ButtonManager::handleButtonRelease(unsigned long pressDuration) {
  unsigned long currentTime = millis();
  
  buttonPressed = false;
  currentState = BUTTON_RELEASED;
  
  Serial.printf("🔘 按钮释放 - 按压时长: %lums\n", pressDuration);
  
  // 按钮释放时恢复WS2812原始状态
  restoreWS2812State();
  
  // 改进的防抖检查 - 使用安全时间差计算
  if (safeTimeDiff(lastButtonPress, currentTime) < DEBOUNCE_DELAY) {
    Serial.printf("🔘 防抖跳过 (距离上次按键%lums)\n", safeTimeDiff(lastButtonPress, currentTime));
    currentState = BUTTON_IDLE;
    return;
  }
  lastButtonPress = currentTime;
  
  // 🎯 根据按压时长执行不同功能 - 按照附件main.cpp的逻辑
  if (pressDuration >= WIFI_RESET_HOLD_TIME) {
    // 长按10秒：WiFi重置
    Serial.println("✅ 长按10秒完成 - 执行WiFi重置");
    onWiFiReset();
    
  } else if (pressDuration >= SYSTEM_POWER_HOLD_TIME) {
    // 长按3秒：系统开关（始终可用）
    Serial.println("✅ 长按3秒完成 - 执行系统休眠/唤醒切换");
    onSystemPowerToggle();
    
  } else if (pressDuration >= SHORT_PRESS_MIN_TIME && pressDuration <= SHORT_PRESS_MAX_TIME) {
    // 短按：开始/停止绘图（只有在系统启用时才可用）
    Serial.println("✅ 短按检测 - 执行start/stop切换");
    if (isSystemEnabled()) {
      onShortPress();
    } else {
      Serial.println("🔘 系统休眠中，短按功能不可用（长按3秒可唤醒系统）");
    }
  } else {
    // 无效的按压时长
    Serial.printf("⚠️ 无效按压时长: %lums (需要50-500ms短按, 3秒长按, 或10秒WiFi重置)\n", pressDuration);
  }
  
  // 重置所有触发标志
  systemPowerTriggered = false;
  wifiResetTriggered = false;
  longPressLogShown = false;
  
  // 延迟后设置为空闲状态
  currentState = BUTTON_IDLE;
}

void ButtonManager::handleLongPress(unsigned long pressDuration) {
  // 🌟 根据按住时长设置不同的灯光颜色提示（但不执行功能）
  if (pressDuration >= WIFI_RESET_HOLD_TIME && !wifiResetTriggered) {
    // 按住10秒以上 - 红色提示（WiFi重置功能）
    wifiResetTriggered = true; // 标记以避免重复设置灯光
    currentState = BUTTON_HELD;
    Serial.println("🔴 红色灯光提示 - 松开将重置WiFi配置");
    if (ledManager != nullptr) {
      if (ledControlCenter) {
        ledControlCenter->setTemporaryColor(LEDColor(255, 0, 0), 100);  // 红色
      }
    }
    
  } else if (pressDuration >= SYSTEM_POWER_HOLD_TIME && !systemPowerTriggered) {
    // 按住3秒以上 - 黄色提示（系统开关功能）
    systemPowerTriggered = true; // 标记以避免重复设置灯光
    currentState = BUTTON_HELD;
    // 只在刚达到3秒阈值时输出一次提示
    if (!longPressLogShown) {
      Serial.println("💛 黄色灯光提示 - 松开将切换系统休眠/唤醒状态");
      longPressLogShown = true;
      if (ledManager != nullptr) {
        if (ledControlCenter) {
          ledControlCenter->setTemporaryColor(LEDColor(255, 255, 0), 100);  // 黄色
        }
      }
    }
  }
  
  // 每秒提示一次剩余时间 - 使用实例变量而非静态变量
  unsigned long currentTime = millis();
  if (safeTimeDiff(lastSecondPrompt, currentTime) >= PROMPT_INTERVAL) {
    if (pressDuration < SYSTEM_POWER_HOLD_TIME) {
      unsigned long remainingMs = SYSTEM_POWER_HOLD_TIME - pressDuration;
      Serial.printf("⏳ 还需按住 %.1f 秒触发系统休眠/唤醒\n", remainingMs / 1000.0);
    } else if (pressDuration < WIFI_RESET_HOLD_TIME) {
      unsigned long remainingMs = WIFI_RESET_HOLD_TIME - pressDuration;
      Serial.printf("⏳ 还需按住 %.1f 秒触发WiFi重置\n", remainingMs / 1000.0);
    }
    lastSecondPrompt = currentTime;
  }
}

void ButtonManager::resetButtonState() {
  bool wasPressed = buttonPressed;  // 记录之前是否被按下
  
  buttonPressed = false;
  wifiResetTriggered = false;
  systemPowerTriggered = false;
  longPressLogShown = false;  // 重置长按日志标志
  buttonPressStart = 0;
  currentState = BUTTON_IDLE;
  
  // 确保恢复WS2812状态
  if (ws2812TemporarilyEnabled) {
    restoreWS2812State();
  }
  
  // 只有在按钮实际被按下时才输出日志
  if (wasPressed) {
    Serial.println("🔘 按钮状态已重置（溢出保护）");
  }
}

bool ButtonManager::isSystemEnabled() {
  return systemPowerEnabled != nullptr && *systemPowerEnabled;
}

// ==================== 事件处理方法 ====================

void ButtonManager::onShortPress() {
  // 验证必要指针
  if (!validatePointers()) {
    Serial.println("❌ ButtonManager: 关键指针无效，无法执行短按操作");
    return;
  }
  
  // 检查系统电源状态
  if (!isSystemEnabled()) {
    Serial.println("❌ 系统处于休眠状态，无法执行绘图命令");
    Serial.println("💡 GPIO17按钮: 短按切换start/stop, 长按3秒启用系统");
    return;
  }
  
  // 🔥 完全按照附件main.cpp中handleShortPressStartStop()的逻辑
  // 根据全局状态标志决定操作，直接模拟串口命令输入
  if (*isDrawingActive) {
    // 当前在绘图，执行停止 - 完全模拟串口"stop"命令
    Serial.println("🛑 短按：当前绘图中，执行停止");
    Serial.println("📤 模拟串口命令: stop");
    
    // 🔥 关键修复：直接调用串口命令处理器的processCommand方法
    // 而不是handleShortPressStartStop，避免循环调用问题
    if (serialCommandHandler != nullptr) {
      serialCommandHandler->processCommand("stop");
    } else {
      // 回退逻辑：直接设置状态（参照附件main.cpp的逻辑）
      *isDrawingActive = false;
      if (isDrawingPaused != nullptr) {
        *isDrawingPaused = true;  // 设置暂停状态
      }
      Serial.println("⏸️ 电机已停止，系统进入暂停状态");
    }
    
  } else {
    // 当前空闲，执行开始 - 直接在当前线程执行串口start的完整逻辑
    Serial.println("🎨 短按：当前空闲，执行开始");
    Serial.println("📤 模拟串口命令: start (在主循环执行)");
    
    // 🔥 关键修复：直接调用串口命令处理器的processCommand方法
    if (serialCommandHandler != nullptr) {
      serialCommandHandler->processCommand("start");
    } else {
      // 回退逻辑：直接设置状态（参照附件main.cpp的逻辑）
      *isDrawingActive = true;
      if (isDrawingPaused != nullptr) {
        *isDrawingPaused = false;
      }
      Serial.println("▶️ 按钮事件: 绘图已开始");
    }
  }
}

void ButtonManager::onSystemPowerToggle() {
  // 验证必要指针
  if (!validatePointers()) {
    Serial.println("❌ ButtonManager: 关键指针无效，无法执行系统电源切换");
    return;
  }
  
  // 🎯 完全按照附件main.cpp中的toggleSystemPower()逻辑
  *systemPowerEnabled = !(*systemPowerEnabled);
  
  if (*systemPowerEnabled) {
    // 启用系统
    Serial.println("🔋 系统唤醒 - 从休眠状态恢复");
    Serial.println("  ✅ 启用电机");
    Serial.println("  ✅ 启用WS2812灯带");
    
    // 启用LED管理器的WS2812（按照附件main.cpp的逻辑）
    if (ledManager != nullptr) {
      if (ledControlCenter) {
        ledControlCenter->enableWS2812(true);
      }
    }
    
    Serial.println("🎉 系统已完全唤醒，可以正常使用绘图功能");
    
  } else {
    // 禁用系统
    Serial.println("💤 系统进入休眠 - 电机和灯带休眠，其他功能正常");
    Serial.println("  💤 电机休眠");
    Serial.println("  💤 WS2812灯带休眠");
    
    // 先停止所有绘图活动（按照附件main.cpp的逻辑）
    if (isDrawingActive != nullptr) {
      *isDrawingActive = false;
    }
    if (isDrawingPaused != nullptr) {
      *isDrawingPaused = false;
    }
    
    // 禁用LED管理器的WS2812（按照附件main.cpp的逻辑）
    if (ledManager != nullptr) {
      if (ledControlCenter) {
        ledControlCenter->enableWS2812(false);
      }
    }
    
    Serial.println("😴 系统已进入休眠状态，WiFi/MQTT等网络功能继续工作，长按3秒可唤醒");
  }
  
  Serial.printf("🔋 当前系统状态: %s\n", *systemPowerEnabled ? "运行中" : "休眠中");
}

void ButtonManager::onWiFiReset() {
  Serial.println("📶 按钮事件: WiFi配置重置");
  Serial.println("✅ 长按10秒完成 - 开始重置WiFi配置");
  
  if (wifiManager != nullptr) {
    // 调用WiFi管理器的重置方法
    Serial.println("🗑️ 清除WiFi凭证...");
    wifiManager->clearWiFiCredentials();
    Serial.println("� 重启系统以应用WiFi重置...");
    
    // 延迟后重启系统
    delay(1000);
    ESP.restart();
  } else {
    Serial.println("❌ WiFi管理器未初始化，无法重置");
  }
}

// ==================== LED临时控制 ====================

void ButtonManager::enableTemporaryWS2812() {
  if (ledControlCenter == nullptr) {
    Serial.println("⚠️ LEDControlCenter未初始化，无法启用临时WS2812");
    return;
  }
  
  ws2812OriginalState = ledControlCenter->isWS2812Enabled();
  if (!ws2812OriginalState) {
    ledControlCenter->enableWS2812(true);
    ws2812TemporarilyEnabled = true;      
    Serial.println("💡 按钮按下：临时启用WS2812显示");
  }
  
  // 显示按钮反馈颜色：避免红色造成误解，使用更友好的颜色
  if (!isSystemEnabled()) {
    ledControlCenter->setTemporaryColor(LEDColor(0, 100, 255), 60);  // 蓝色 - 休眠状态（可长按启用）
  } else {
    ledControlCenter->setTemporaryColor(LEDColor(0, 255, 100), 80);  // 绿色 - 正常运行状态
  }
}

void ButtonManager::restoreWS2812State() {
  if (ledControlCenter == nullptr) {
    Serial.println("⚠️ LEDControlCenter未初始化，无法恢复WS2812状态");
    return;
  }
  
  // 清除临时颜色
  ledControlCenter->clearTemporaryColor();
  
  if (ws2812TemporarilyEnabled) {
    ledControlCenter->enableWS2812(ws2812OriginalState);
    ws2812TemporarilyEnabled = false;
    Serial.println("💡 按钮释放：恢复WS2812原始状态");
  }
}

// ==================== 状态查询和调试 ====================

unsigned long ButtonManager::getPressDuration() const {
  if (!buttonPressed) return 0;
  // 使用const_cast来调用非const方法，这在此处是安全的
  return const_cast<ButtonManager*>(this)->safeTimeDiff(buttonPressStart, millis());
}

void ButtonManager::printStatus() {
  Serial.println("=== 按钮管理器状态 ===");
  Serial.printf("按钮引脚: %d\n", buttonPin);
  Serial.printf("当前状态: %d\n", currentState);
  Serial.printf("按下状态: %s\n", buttonPressed ? "是" : "否");
  Serial.printf("连续读取次数: %d\n", consecutiveReadings);
  Serial.printf("上次读取状态: %s\n", lastReadingState == LOW ? "按下" : "释放");
  
  if (buttonPressed) {
    Serial.printf("按压时长: %lums\n", getPressDuration());
  }
  
  Serial.printf("系统状态: %s\n", isSystemEnabled() ? "运行中" : "休眠中");
  Serial.printf("绘图状态: %s\n", (isDrawingActive && *isDrawingActive) ? "活动" : "停止");
  Serial.printf("WS2812临时启用: %s\n", ws2812TemporarilyEnabled ? "是" : "否");
  Serial.printf("指针验证: %s\n", validatePointers() ? "通过" : "失败");
  
  // 显示时间差信息
  unsigned long currentTime = millis();
  Serial.printf("系统运行时间: %lums\n", currentTime);
  if (buttonPressed) {
    Serial.printf("按钮按下时间: %lums\n", buttonPressStart);
  }
  
  Serial.println("=====================");
}
